数据结构-二叉查找树

 

 

 

 

 

 

 

 

 

前序遍历：

   

后序遍历：

 

二叉查找树按照二叉树进行组织。二叉查找树关键字的存储方式总是瞒住二叉查找树性质：

设x为二查查找树种一个节点。如果y是x的左子树中的一个节点，那么key[x] >= key[y]。如果y是x的右子树的一个节点，那么key[x] <= key[y]。

这样对二叉查找树进行中序遍历就可得到书中所有元素的一个非降序排列。

查找某一个存在节点的前驱和后继。某一个节点x的后继就是大于key[x]的关键字中最小的那个节点，前驱就是小于key[x]的关键字中最大的那个节点。查找二叉前驱和后继节点的算法如下所示：

 

typedef struct _node {  
    struct _node *left_child;  
    struct _node *right_child;  
    struct _node * parent;
    ctype    data;  
}node; //树节点数据结构定义

typedef node* Tree;

//查找二叉查找树中关键字最小的节点，返回指向该节点的指针
Tree tree_minimum(Tree root)
{
    Tree p = root;
    while (p->left_child != null)
        p = p->left_child;
    return p;
}

//查找二叉查找树中关键字最大的节点，返回指向该节点的指针
Tree tree_maxmum(Tree root)
{
    Tree p = root;

    while (p->right_child != null)
    {
        p = p->right_child;
    }
    return p;
}

//查找二叉查找树中节点x的后继节点，返回指向该节点的指针
//在查找过程中，如果节点x右子树不为空，那么返回右子树的最小节点即可
//如果节点x的右子树为空，那么后继节点为x的某一个祖先节点的父节点，而且该祖先节点是作为其父节点的左儿子
Tree tree_successor(Tree x)
{
    if (x->right_child != null)
        return tree_minimum(x->right_child);
    
    //x用来保存待确定的节点
    //y为x的父节点
    Tree y = x->parent;

    while (y != NULL && x == y->right_child)
    {
        x = y;
        y = y->parent;
    }
    return y;
}


//查找二叉查找树中节点x的前驱节点，返回指向该节点的指针
//在查找过程中，如果节点x左子树不为空，那么返回左子树的最大节点即可
//如果节点x的左子树为空，那么前驱节点为x的某一个祖先节点的父节点，而且该祖先节点是作为其父节点的右儿子
Tree tree_predecessor(Tree x)
{
    if (x->left_child != null)
        return tree_maxmum(x->left_child);

    Tree y = x->parent;
    while (y != NULL && x == y->left_child)
    {
        x = y;
        y = y->parent;
    }
    return y;
}

 

                          

                      

 

插入算法

首先执行查找算法，找出被插结点的父亲结点。

判断被插结点是其父亲结点的左、右儿子。将被插结点作为叶子结点插入。

若二叉树为空。则首先单独生成根结点。

注意：新插入的结点总是叶子结点。

 

 

 

 

 

struct BiTree {
    int data;
    BiTree *lchild;
    BiTree *rchild;
};
 
//在二叉排序树中插入查找关键字key
BiTree* InsertBST(BiTree *t,int key)
{
    if (t == NULL)
    {
        t = new BiTree();
        t->lchild = t->rchild = NULL;
        t->data = key;
        return t;
    }
 
    if (key < t->data) 
        t->lchild = InsertBST(t->lchild, key);
    else
        t->rchild = InsertBST(t->rchild, key);
 
    return t;
}
 
//n个数据在数组d中，tree为二叉排序树根
BiTree* CreateBiTree(BiTree *tree, int d[], int n)
{
    for (int i = 0; i < n; i++)
        tree = InsertBST(tree, d[i]);
    return tree;
}

三、二叉搜索树的删除

       对于二叉搜索树的删除操作，主要是要理解其中的几种情况，写起来还是比较简单的。

当然一开始还是需要判断要删除的节点是否存在于我们的树中，如果要删除的元素都不在树中，就直接返回false；否则，再分为以下四种情况来进行分析：

     》要删除的节点无左右孩子

     》要删除的节点只有左孩子

     》要删除的节点只有右孩子

     》要删除的节点有左、右孩子

 

删除方法解释：

     对于第一种情况，我们完全可以把它归为第二或者第三种情况，就不用再单独写一部分代码进行处理；

     》如果要删除的节点只有左孩子，那么就让该节点的父亲结点指向该节点的左孩子，然后删除该节点，返回true；

          

     》如果要删除的节点只有右孩子，那么就让该节点的父亲结点指向该节点的右孩子，然后删除该节点，返回true；

            

          对于上面这两种情况我们还应该在之前进行一个判断，就是判断这个节点是否是根节点，如果是根节点的话，就直接让根节点指向这个节点的左孩子或右孩子，然后删除这个节点。

       》最后一种也是最麻烦的一种就是要删除的节点的左右孩子都存在。此时我们的删除方法如下：

           1、找到该节点的右子树中的最左孩子（也就是右子树中序遍历的第一个节点）

           2、把它的值和要删除的节点的值进行交换

           3、然后删除这个节点即相当于把我们想删除的节点删除了，返回true；

        

bool Remove(const K& key)
    {
        assert(_root);
        Node* parent = NULL;
        Node* pcur = _root;
        Node* del = pcur;
        while (pcur != NULL  && pcur->_key != key)
        {
            if (pcur->_key > key)
            {
                parent = pcur;
                pcur = pcur->_left;
            }
            else if (pcur->_key < key)
            {
                parent = pcur;
                pcur = pcur->_right;
            }
        }
        if (pcur == NULL)
            return false;
        if (pcur->_left == NULL)      //只有右孩子
        {
            //如果pcur就是根节点的话，让根节点指向根的右
            if (pcur == _root)
                _root = pcur->_right;
            else if (pcur == parent->_left) 
            {
                parent->_left = pcur->_right;
            }
            else
            {
                parent->_right = pcur->_right;
            }
            del = pcur;
        }
        else if (pcur->_right == NULL)     //只有左孩子
        {
           //如果是根节点，让根节点指向根的左
            if (pcur == _root)
                _root = pcur->_left;
            else if (parent->_left == pcur)
            {
                parent->_left = pcur->_left;
            }
            else
                parent->_right = pcur->_left;
            del = pcur;
        }
        //pcur左右孩子都不为空
        else
        {
           //找到节点右子树的最左节点
            Node* left = pcur->_right;
            parent = pcur;
            while (left->_left)     
            {
                parent=left;
                left = left->_left;
            }
            del = left;
            pcur->_key = left->_key;   //交换节点的值
            if (parent->_left == left)
            {
                parent->_left = left->_right;
            }
            else
            {
                parent->_right = left->_right;
            }

        }
        delete del;
        return true;
    }

 

===================================================================